PesticideMap Class Reference

#include <pesticide.h>

Public Member Functions
	PesticideMap (int a_startyear, int a_noyears, int a_cellsize, Landscape *a_landscape, RasterMap *a_land, bool a_typeofmap)
	~PesticideMap ()
bool	DumpPMap (vector< double > *a_map)
bool	DumpPMapI ()
bool	DumpPMapH ()
bool	DumpPMapF ()
void	Spray (LE *a_element_sprayed, TTypesOfPesticideCategory a_type)

Protected Attributes
vector< double > *	m_pmap_insecticides
	insecticide map data More...
vector< double > *	m_pmap_fungicides
	herbicide map data More...
vector< double > *	m_pmap_herbicides
	fungicide map data More...
int	m_startyear
	first simultion year to record More...
int	m_endyear
	last year of data to record More...
int	m_cellsize
	the size of the cell for pesticide data in m More...
int	m_pmap_width
	based on cellsize the width of the map More...
int	m_pmap_height
	based on cellsize the height of the map More...
bool	m_typeofmap
	true if using test pesticide, false for general pesticides More...
Landscape *	m_OurLandscape
	pointer to the landscape More...
RasterMap *	m_Rastermap
	pointer to the landscape map More...

Constructor & Destructor Documentation

PesticideMap()

PesticideMap::PesticideMap	(	int	a_startyear,
		int	a_noyears,
		int	a_cellsize,
		Landscape *	a_landscape,
		RasterMap *	a_land,
		bool	a_typeofmap
	)

{
    m_typeofmap = a_typeofmap;
    m_startyear = a_startyear;
    m_endyear = a_startyear + a_noyears;
    m_cellsize = a_cellsize;
    m_OurLandscape = a_landscape;
    m_Rastermap = a_land;
    m_pmap_width = m_OurLandscape->SupplySimAreaWidth() / m_cellsize;
    m_pmap_height = m_OurLandscape->SupplySimAreaHeight() / m_cellsize; ;
 
    // Need to create the grid to fill. This grid is always used.
    m_pmap_insecticides = new vector<double>;
    m_pmap_insecticides->resize(m_pmap_width*m_pmap_height);
    fill(m_pmap_insecticides->begin(), m_pmap_insecticides->end(), 0);
    ofstream * m_PMap;
    m_PMap = new ofstream("ALMaSS_InsecticideMap.txt", ios::out);
    (*m_PMap) << "Years" << ' ' << a_noyears << ' ' << "Height" << ' ' << m_pmap_height << ' ' << "Width" << ' ' << m_pmap_width << ' ' << endl;
    m_PMap->close();
    // These two grids are used only if we want all three types recoreded.
    if (!m_typeofmap)
    {
        // We need all three in this case
        m_pmap_fungicides = new vector<double>;
        m_pmap_fungicides->resize(m_pmap_width*m_pmap_height);
        fill(m_pmap_fungicides->begin(), m_pmap_fungicides->end(), 0);
        m_PMap = new ofstream("ALMaSS_FungicideMap.txt", ios::out);
        (*m_PMap) << "Years" << ' ' << a_noyears << ' ' << "Height" << ' ' << m_pmap_height << ' ' << "Width" << ' ' << m_pmap_width << ' ' << endl;
        m_PMap->close();
        m_pmap_herbicides = new vector<double>;
        m_pmap_herbicides->resize(m_pmap_width*m_pmap_height);
        fill(m_pmap_herbicides->begin(), m_pmap_herbicides->end(), 0);
        m_PMap = new ofstream("ALMaSS_HerbicideMap.txt", ios::out);
        (*m_PMap) << "Years" << ' ' << a_noyears << ' ' << "Height" << ' ' << m_pmap_height << ' ' << "Width" << ' ' << m_pmap_width << ' ' << endl;
        m_PMap->close();
    }
    else
    {
        m_pmap_fungicides = NULL;
        m_pmap_herbicides = NULL;
    }
}

~PesticideMap()

PesticideMap::~PesticideMap

(

)

{
    delete m_pmap_insecticides;
    if (!m_typeofmap)
    {
        // We need all three in this case
        delete m_pmap_fungicides;
        delete m_pmap_herbicides;
 
    }
}

Member Function Documentation

DumpPMap()

bool PesticideMap::DumpPMap

(

vector< double > *

a_map

)

{
    string fname;
    if (a_map == m_pmap_insecticides) fname = "ALMaSS_InsecticideMap.txt";
    else if (a_map == m_pmap_fungicides) fname = "ALMaSS_FungicideMap.txt";
    else  fname = "ALMaSS_HerbicideMap.txt";
    {
        ofstream* m_PMap = new ofstream(fname.c_str(), ios::app);
        if (!(*m_PMap).is_open())
        {
            g_msg->Warn(WARN_FILE, "PesticideMap::DumpMap Unable to open file for append: ", fname.c_str());
            exit(1);
        }
        // File is OK, save the map
        (*m_PMap) << "Year " << g_date->GetYear() << "Month " << g_date->GetMonth() << endl;
        for (int y = 0; y < m_pmap_height; y++)
        {
            for (int x = 0; x < m_pmap_width; x++)
            {
                (*m_PMap) << (*a_map)[y*m_pmap_width + x] << ' ';
            }
        }
        (*m_PMap) << endl;
        m_PMap->close();
    }
    fill(a_map->begin(), a_map->end(), 0);
    return true;
}

References g_date, g_msg, Calendar::GetMonth(), Calendar::GetYear(), MapErrorMsg::Warn(), and WARN_FILE.

Referenced by DumpPMapF(), DumpPMapH(), and DumpPMapI().

DumpPMapF()

bool PesticideMap::DumpPMapF ( )

inline

{ return DumpPMap(m_pmap_fungicides); }

References DumpPMap(), and m_pmap_fungicides.

DumpPMapH()

bool PesticideMap::DumpPMapH ( )

inline

{ return DumpPMap(m_pmap_herbicides); }

References DumpPMap(), and m_pmap_herbicides.

DumpPMapI()

bool PesticideMap::DumpPMapI ( )

inline

{ return DumpPMap(m_pmap_insecticides); }

References DumpPMap(), and m_pmap_insecticides.

Spray()

void PesticideMap::Spray	(	LE *	a_element_sprayed,
		TTypesOfPesticideCategory	a_type
	)

This records a 1 in the map for every m2 where pesticide is applied. This does not record drift.

Going through the whole landscape is very slow and unnecessary for small polygons. Since our polygons do not extend beyond the edge of the map ie do not wrap round, then we only need a measure of minx, maxx, miny, maxy. This is set up at the start of the simulation.

This method first determines what type of pesticide and selects the correct map to record on.

{
    vector<double>* ourmap = m_pmap_insecticides; ;
    if (a_type == fungicide) ourmap = m_pmap_fungicides;
    else if (a_type == herbicide) ourmap = m_pmap_herbicides;
    int l_large_map_index = a_element_sprayed->GetMapIndex();
    int minx = a_element_sprayed->GetMinX();
    int miny = a_element_sprayed->GetMinY();
    int maxx = a_element_sprayed->GetMaxX();
    int maxy = a_element_sprayed->GetMaxY();
    for (int y = miny; y <= maxy; y++) {
        for (int x = minx; x <= maxx; x++) {
            if (m_Rastermap->Get(x, y) == l_large_map_index)
            {
                // Add one m spray value of 1.0 per m
                (*ourmap)[(x/m_cellsize)+(y/m_cellsize)*m_pmap_width]++;
            }
        }
    }
}

References fungicide, LE::GetMapIndex(), LE::GetMaxX(), LE::GetMaxY(), LE::GetMinX(), LE::GetMinY(), and herbicide.

Member Data Documentation

m_cellsize

int PesticideMap::m_cellsize

protected

the size of the cell for pesticide data in m

m_endyear

int PesticideMap::m_endyear

protected

last year of data to record

m_OurLandscape

Landscape* PesticideMap::m_OurLandscape

protected

pointer to the landscape

m_pmap_fungicides

vector<double>* PesticideMap::m_pmap_fungicides

protected

herbicide map data

Referenced by DumpPMapF().

m_pmap_height

int PesticideMap::m_pmap_height

protected

based on cellsize the height of the map

m_pmap_herbicides

vector<double>* PesticideMap::m_pmap_herbicides

protected

fungicide map data

Referenced by DumpPMapH().

m_pmap_insecticides

vector<double>* PesticideMap::m_pmap_insecticides

protected

insecticide map data

PesticideMap is a class for handling pesticide mapping output. This can be used to sum up pesticide concentrations over time. It works currently for general pesticides split into insecticides, herbicides, and fungicides, but also for the primary test pesticide if one is being used.

Referenced by DumpPMapI().

m_pmap_width

int PesticideMap::m_pmap_width

protected

based on cellsize the width of the map

m_Rastermap

RasterMap* PesticideMap::m_Rastermap

protected

pointer to the landscape map

m_startyear

int PesticideMap::m_startyear

protected

first simultion year to record

m_typeofmap

bool PesticideMap::m_typeofmap

protected

true if using test pesticide, false for general pesticides

---

The documentation for this class was generated from the following files:

• /builds/a1mass/almass_stable_oddox/Landscape/pesticide.h
• /builds/a1mass/almass_stable_oddox/Landscape/pesticide.cpp